package com.internetCafes.spms.core.utils;

import com.internetCafes.spms.core.common.Utility;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;

/**
 * 日期处理
 *
 * @author Sunny
 * @email rekeeper2011@hotmail.com
 * @date 2016年12月21日 下午12:53:33
 */
public class DateUtils {

    public static final String STYLE_DATE_TIME = "yyyy-MM-dd HH:mm:ss";

    public static final String STYLE_DATE = "yyyy-MM-dd";

    public static final String STYLE_DATE_TIME_CN = "yyyy年MM月dd日";

    public static final String STYLE_DATE_CN = "yyyy年MM月dd日";

    public static final String STYLE_TIME_CN = "HH时mm分ss秒";


    /**
     * 字符串转为日期，自定义格式
     */
    public static Date stringToDate(String str, String pattern) {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        try {
            return sdf.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return new Date();
    }

    /**
     * 默认
     *
     * @param date
     * @return
     */
    public static String format(Date date) {
        return format(date, STYLE_DATE);
    }

    /**
     * 按指定样式格式化日期时间.
     *
     * @param datetime Date对象
     * @param format   格式，例如："yyyy-MM-dd HH:mm:ss"
     * @return String 指定样式的时间格式的串,例如：返回'2006-08-30 16:00'
     */
    public static String format(Date datetime, String format) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat(format, Locale.getDefault());
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 按指定样式格式化日期时间.
     *
     * @param datetime Date对象
     * @param format   格式，例如："yyyy-MM-dd HH:mm:ss"
     * @param locale   本地化
     * @return String 指定样式的时间格式的串,例如：返回'2006-08-30 16:00'
     */
    public static String format(Date datetime, String format, Locale locale) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat(format, locale);
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化日期时间(系统标准时间)
     * 格式："yyyy-MM-dd HH:mm:ss".
     *
     * @param datetime Date对象
     * @return String para的标准时间格式的串,例如：返回'2006-08-30 16:00:00'
     */
    public static String formatDateTime(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat(STYLE_DATE_TIME);
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化日期时间(系统标准时间)
     * 格式："yyyy-MM-dd".
     *
     * @param datetime Date对象
     * @return String 标准时间格式的串,例如：返回'2006-08-30'
     */
    public static String formatDate(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat(STYLE_DATE);
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化日期成整型
     * 格式："yyyyMMdd".
     *
     * @param datetime Date对象
     * @return int para的标准时间格式的串,例如：返回'20060830'
     */
    public static String formatDateNum(Date datetime) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        return dateFormat.format(datetime);
    }

    /**
     * 格式化日期时间(整型)
     * 格式："yyyyMMddHHmmss".
     *
     * @param datetime Date对象
     * @return yyyyMMddHHmmss的时间格式的串, 例如：返回'20060830123001'
     * @since 2008-11-12
     */
    public static String formatDateTimeNum(Date datetime) {
        if (datetime == null)
            return null;
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        return dateFormat.format(datetime);
    }

    /**
     * 格式化时间(系统标准时间)
     * 格式："HH:mm:ss"
     *
     * @return String 标准时间格式的串,例如：返回'16:00:00'
     */
    public static String formatTime(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化成中文日期时间
     * 格式："yyyy年MM月dd日 HH时mm分ss秒"
     *
     * @return String 中文格式化时间日期格式的串,例如：返回'2006年08月30日 16时00分00秒'
     */
    public static String formatDateTimeCn(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化成中文日期.
     * 格式："yyyy年MM月dd日"
     *
     * @return String 中文格式化日期格式的串,例如：返回'16时00分00秒'
     */
    public static String formatDateCn(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日");
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 格式化成中文时间
     * 格式："HH时mm分ss秒"
     *
     * @return String 中文格式化时间格式的串,例如：返回'16:00:00'
     */
    public static String formatTimeCn(Date datetime) {
        if (datetime == null)
            return "";
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH时mm分ss秒");
        String date = dateFormat.format(datetime);
        return date;
    }

    /**
     * 将Date转换成Timestamp类型.
     *
     * @param date 日期时间
     * @return Timestamp 转换失败则返回NULL
     */
    public static Timestamp convertDate2Timestamp(Date date) {
        if (date == null)
            return null;
        try {
            return new Timestamp(date.getTime());
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将Date转换成Timestamp类型.
     *
     * @param date         日期时间
     * @param defaultValue 默认值
     * @return Timestamp 转换失败则返回defaultValue
     */
    public static Timestamp convertDate2Timestamp(Date date, Date defaultValue) {
        if (date == null)
            return new Timestamp(defaultValue.getTime());
        try {
            return new Timestamp(date.getTime());
        } catch (Exception e) {
            return new Timestamp(defaultValue.getTime());
        }
    }

    /**
     * 将java.util.Date型时间转换成java.sql.Date.
     *
     * @param datetime java.util.Date
     * @return java.sql.Date 转换失败则返回NULL
     */
    public static java.sql.Date convertDate2SqlDate(Date datetime) {
        try {
            java.sql.Date date = new java.sql.Date(datetime.getTime());
            return date;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将java.sql.Date型时间转换成java.util.Date.
     *
     * @param datetime java.sql.Date(年月日)
     * @return Date 转换失败则返回NULL
     */
    public static Date convertSqlDate2Date(java.sql.Date datetime) {
        try {
            Date date = new Date(datetime.getTime());
            return date;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将java.sql.Time型时间转换成java.util.Date.
     *
     * @param datetime java.sql.Time(时分秒)
     * @return Date 转换失败则返回NULL
     */
    public static Date convertSqlTimeToDate(java.sql.Time datetime) {
        try {
            Date date = new Date(datetime.getTime());
            return date;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将java.sql.Timestamp型时间转换成java.util.Date.
     *
     * @param datetime java.sql.Timestamp
     * @return Date 转换失败则返回NULL
     */
    public static Date convertSqlTimestampToDate(java.sql.Timestamp datetime) {
        try {
            Date date = new Date(datetime.getTime());
            return date;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 得到今天的日期（时分秒为0）.
     *
     * @return Date 当前日期
     */
    public static Date getCurrentDate() {
        return Utility.parseDate(formatDate(new Date()));
    }

    /**
     * 得到今天的标准格式表示，例如：返回'2006-08-30'.
     *
     * @return String 当前日期的标准格式表示
     */
    public static String getCurrentDateString() {
        return formatDate(new Date());
    }

    /**
     * 得到今天的整型表示，例如：返回'20060830'.
     *
     * @return int 当前日期的整型表示
     */
    public static int getCurrentDateInt() {
        return Utility.parseInt(formatDateNum(new Date()));
    }

    /**
     * 格式化日期成整型
     * 格式："yyyyMMdd".
     *
     * @param datetime Date对象
     * @return int para的标准时间格式的串,例如：返回'20060830'
     */
    public static int getDateInt(Date datetime) {
        return Utility.parseInt(formatDateNum(datetime));
    }

    /**
     * 获得当前时间的标准格式表示.
     * 例如：返回'13:01:20'
     *
     * @return String
     */
    public static String getCurrentTimeString() {
        return formatTime(new Date());
    }

    /**
     * 获得当前时间的整型表示.
     * 例如：返回'130120'
     *
     * @return int
     */
    public static int getCurrentTimeInt() {
        DateTime dt = new DateTime();
        return dt.getHourOfDay() * 10000 + dt.getMinuteOfHour() * 100 + dt.getSecondOfMinute();
    }

    /**
     * 获得当前小时的整型表示.
     * 例如：返回'13'
     *
     * @return int
     */
    public static int getCurrentHourInt() {
        DateTime dt = new DateTime();
        return dt.getHourOfDay();
    }

    /**
     * 得到当前的年月.
     *
     * @return 以整型输出(格式 : YYYYMM)
     */
    public static int getCurrentYeatMonthInt() {
        Calendar dStart = Calendar.getInstance();
        dStart.setTime(new Date());
        return dStart.get(Calendar.YEAR) * 100 + (dStart.get(Calendar.MONTH) + 1);
    }

    /**
     * 得到整型年月.
     *
     * @return 以整型输出(格式 : YYYYMM)
     */
    public static int getYeatMonthInt(Date date) {
        DateTime dt = new DateTime(date);
        return dt.getYear() * 100 + dt.getMonthOfYear();
    }

    /**
     * 得到当前的年份.
     *
     * @return 以整型输出(格式 : YYYY)
     */
    public static int getCurrentYearInt() {
        Calendar dStart = Calendar.getInstance();
        dStart.setTime(new Date());
        return dStart.get(Calendar.YEAR);
    }

    /**
     * 得到当前的月份.
     *
     * @return 以整型输出(格式 : MM)
     */
    public static int getCurrentMonthInt() {
        Calendar dStart = Calendar.getInstance();
        dStart.setTime(new Date());
        return dStart.get(Calendar.MONTH) + 1;
    }

    /**
     * 得到当前时刻的时间字符串,例如：返回'2006-08-30 16:00:00'.
     *
     * @return String 当前时间的标准格式表示
     */
    public static String getCurrentDateTimeString() {
        return formatDateTime(new Date());
    }

    /**
     * 得到当前时刻的时间字符串,例如：返回'2006-08-30 16:00:00'.
     *
     * @return String 当前时间的标准格式表示
     * @since 2008-11-12
     */
    public static Long getCurrentDateTimeLong() {
        return Utility.parseLong(formatDateTimeNum(new Date()));
    }

    /**
     * 得到当前时刻的时间字符串,例如：返回'2006-08-30 16:00:00.001'.
     *
     * @return Timestamp 当前系统时间的Timestamp表示
     */
    public static Timestamp getCurrentTimestamp() {
        return new Timestamp(System.currentTimeMillis());
    }

    /**
     * 得到当前时刻的指定格式字符串 例如：样式'yyyy-MM-dd HH:mm',返回'2006-08-30 16:00'.
     *
     * @param format 显示格式
     * @return String 当前时间指定样式的表示
     */
    public static String getCurrentDateTime(String format) {
        return format(new Date(), format);
    }

    /**
     * 得到当前时间的中文字符串，例如：返回'2006年08月30日 16时00分00秒'.
     *
     * @return String 当前时间的中文表示
     */
    public static String getCurrentDateTimeCn() {
        return formatDateTimeCn(new Date());
    }

    /**
     * 得到当前日期的中文格式化输出，格式:YYYY年MM月DD日.
     *
     * @return 当前日期的中文表示
     */
    public static String getCurrentDateCn() {
        return formatDateCn(new Date());
    }

    /**
     * 判断指定日期所在的年份是否为闰年.
     *
     * @param date 指定日期
     * @return boolean 是闰年返回true，不是返回false
     */
    public static boolean isLeapYear(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        return calendar.isLeapYear(calendar.get(GregorianCalendar.YEAR));
    }

    /**
     * 得到当前时间的前或后N月.
     *
     * @param n 加减月数，正数加，负数减
     * @return Date
     */
    public static Date getBeAfMonth(int n) {
        return getBeAfMonth(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N月.
     *
     * @param n    加减月数，正数加，负数减
     * @param date the date
     * @return Date
     */
    public static Date getBeAfMonth(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, n);
        return calendar.getTime();
    }

    /**
     * 得到指定时间的前或后N月.
     *
     * @param n    加减月数，正数加，负数减
     * @param date the date
     * @return Date
     */
    public static Date getBeAfYear(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.YEAR, n);
        return calendar.getTime();
    }

    /**
     * 得到当前时间的前或后N星期.
     *
     * @param n 加减星期数，正数加，负数减
     * @return Date
     */
    public static Date getBeAfWeek(int n) {
        return getBeAfWeek(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N星期.
     *
     * @param n    加减星期数，正数加，负数减
     * @param date the date
     * @return Date
     */
    public static Date getBeAfWeek(Date date, int n) {
        if (n == 0)
            return date;
        DateTime dt = new DateTime(date);
        return dt.plusWeeks(n).toDate();
    }

    /**
     * 得到当前时间的前或后N天.
     *
     * @param n 加减天数，正数加，负数减
     * @return Date
     */
    public static Date getBeAfDay(int n) {
        return getBeAfDay(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N天.
     *
     * @param n    加减天数，正数加，负数减
     * @param date the date
     * @return Date
     */
    public static Date getBeAfDay(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, n);
        return calendar.getTime();
    }

    /**
     * 得到当前时间的前或后N小时.
     *
     * @param n 加减小时，正数加，负数减
     * @return Date
     */
    public static Date getBeAfHour(int n) {
        return getBeAfHour(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N小时.
     *
     * @param date 指定时间
     * @param n    加减小时，正数加，负数减
     * @return Date
     */
    public static Date getBeAfHour(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.HOUR, n);
        return calendar.getTime();
    }

    /**
     * 得到当前时间的前或后N分钟.
     *
     * @param n 加减分钟，正数加，负数减
     * @return Date
     */
    public static Date getBeAfMinute(int n) {
        return getBeAfMinute(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N分钟.
     *
     * @param date 指定时间
     * @param n    加减分钟，正数加，负数减
     * @return Date
     */
    public static Date getBeAfMinute(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, n);
        return calendar.getTime();
    }

    /**
     * 得到当前时间的前或后N秒.
     *
     * @param n 加减秒，正数加，负数减
     * @return Date
     */
    public static Date getBeAfSecond(int n) {
        return getBeAfSecond(new Date(), n);
    }

    /**
     * 得到指定时间的前或后N秒.
     *
     * @param date 指定时间
     * @param n    加减秒，正数加，负数减
     * @return Date 返回值
     */
    public static Date getBeAfSecond(Date date, int n) {
        if (n == 0)
            return date;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, n);
        return calendar.getTime();
    }

    /**
     * 比较当前时间是否在两个时间当中.
     *
     * @param endDateTime   结束日期
     * @param beginDateTime 开始日期
     * @return boolean 在返回true，不在返回false
     */
    public static boolean isBetween(Date beginDateTime, Date endDateTime) {
        java.util.Date currentDate = new java.util.Date();
        return currentDate.after(beginDateTime) && currentDate.before(endDateTime);
    }

    /**
     * 比较某个时间是否在当前年当中.
     *
     * @param currentDate   结束日期
     * @return boolean 在返回true，不在返回false
     */
    public static boolean inCurrentYear(Date currentDate) {
        Date currYearFirstDay = getCurrYearFirst();
        Date currYearLastDay = getCurrYearLast();
        return currYearLastDay.after(currentDate) && currYearFirstDay.before(currentDate);
    }

    public static int getBetweenWeeks(Date date1, Date date2) {
        DateTime dt1 = new DateTime(date1);
        DateTime dt2 = new DateTime(date2);

        int years = dt2.getYear() - dt1.getYear();
        int weeks = dt2.getWeekOfWeekyear() - dt1.getWeekOfWeekyear();

        return years * 48 + weeks;
    }


    /**
     * 得到两个日期间相差的月数.
     *
     * @param date1 开始日期
     * @param date2 结束日期
     * @return int 月数
     */
    public static int getBetweenMonths(Date date1, Date date2) {
        DateTime dt1 = new DateTime(date1);
        DateTime dt2 = new DateTime(date2);

        int years = dt2.getYear() - dt1.getYear();
        int months = dt2.getMonthOfYear() - dt1.getMonthOfYear();

        return years * 12 + months;
    }

    /**
     * 得到两个日期间相差的天数,包括了小时、分秒，如果两个时间相差不超过一天按0天算.
     *
     * @param date1 开始日期
     * @param date2 结束日期
     * @return int 天数
     */
    public static int getBetweenDaysFull(Date date1, Date date2) {
        long diff = date2.getTime() - date1.getTime();
        long days = diff / 86400000L;
        return new Long(days).intValue();
    }

    /**
     * 得到两个日期间相差的天数,只按天算，即使实际时间间隔小于1天.
     *
     * @param startTime 开始日期
     * @param endTime   结束日期
     * @return int 天数
     */
    public static int getBetweenDays(Date startTime, Date endTime) {
        DateTime dt1 = new DateTime(startTime);
        DateTime dt2 = new DateTime(endTime);

        long diff = dt2.toDateMidnight().getMillis() - dt1.toDateMidnight().getMillis();
        long days = diff / 86400000L;
        return (int) days;
    }

    /**
     * 得到两个日期间相差的小时数.
     *
     * @param date1 开始日期
     * @param date2 结束日期
     * @return int 小时数
     */
    public static int getBetweenHours(Date date1, Date date2) {
        long diff = date2.getTime() - date1.getTime();
        long days = diff / 3600 / 1000;
        return new Long(days).intValue();
    }

    /**
     * 得到两个日期间相差的分钟数.
     *
     * @param date1 开始日期
     * @param date2 结束日期
     * @return int 分钟数
     */
    public static long getBetweenMinutes(Date date1, Date date2) {
        if (date1 == null || date2 == null)
            return 0;
        long diff = date2.getTime() - date1.getTime();
        long minutes = diff / 60 / 1000;
        return minutes;
    }

    /**
     * 得到两个日期间相差的秒数.
     *
     * @param date1 开始日期
     * @param date2 结束日期
     * @return int 秒数
     */
    public static long getBetweenSeconds(Date date1, Date date2) {
        if (date1 == null || date2 == null)
            return 0;
        long diff = date2.getTime() - date1.getTime();
        long seconds = diff / 1000;
        return seconds;
    }

    /**
     * 获得当前日在月中的位置
     *
     * @return int day
     */
    public static int getDayOfMonth() {
        return getDayOfMonth(new Date());
    }

    /**
     * 获得日在月中的位置.
     *
     * @param date 日期
     * @return int day
     */
    public static int getDayOfMonth(Date date) {
        DateTime dt = new DateTime(date);
        return dt.getDayOfMonth();
    }

    /**
     * 获得指定天的开始00:00:00.
     *
     * @param date 指定日期
     * @return Date
     */
    public static Date getStartOfDay(Date date) {
        DateTime dt = new DateTime(date);
        dt = dt.withTime(0, 0, 0, 0);
        return dt.toDate();
    }


    /**
     * 获得指定天的23:59:59.
     *
     * @param date 指定日期
     * @return Date
     */
    public static Date getEndOfDay(Date date) {
        DateTime dt = new DateTime(date);
        dt = dt.withTime(23, 59, 59, 0);
        return dt.toDate();
    }


    /**
     * 获得指定天的开始00:00:00.
     *
     * @return Date
     */
    public static Date getStartOfDay(String dateStr) {
        return stringToDate(dateStr + " 00:00:00", STYLE_DATE_TIME);
    }


    /**
     * 获得指定天的23:59:59.
     *
     * @return Date
     */
    public static Date getEndOfDay(String dateStr) {
        return stringToDate(dateStr + " 23:59:59", STYLE_DATE_TIME);
    }



    /**
     * 获得当月第一天的.
     *
     * @return Date
     */
    public static Date getFirstOfMonth() {
        return getFirstOfMonth(new Date());
    }


    /**
     * 获得当月第一天的.
     *
     * @param date 指定日期
     * @return Date
     */
    public static Date getFirstOfMonth(Date date) {
        //得到下个月的第一天，再减一
        DateTime dt = new DateTime(date);
        dt = dt.withDayOfMonth(1);
        return dt.toDate();
    }

    /**
     * 获得当月最后一天的.
     *
     * @return Date
     */
    public static Date getLastOfMonth() {
        return getLastOfMonth(new Date());
    }


    /**
     * 获得当月最后一天的.
     *
     * @param date 指定日期
     * @return Date
     */
    public static Date getLastOfMonth(Date date) {
        //得到下个月的第一天，再减一
        DateTime dt = new DateTime(date);
        dt = dt.plusMonths(1);    //先加1个月
        DateTime nextFirstDate = new DateTime(dt.getYear(), dt.getMonthOfYear(), 1, 23, 59, 59, 0);    //取得这个月的第一天
        nextFirstDate = nextFirstDate.minusDays(1);    //再减1天
        return nextFirstDate.toDate();
    }

    /**
     * 获得当前日期所在周的第一天(星期一).
     *
     * @return Date
     */
    public static Date getFirstOfWeek() {
        return getFirstOfWeek(new Date());
    }

    /**
     * 获得日期所在周的第一天(星期一).
     *
     * @param date 日期
     * @return Date
     */
    public static Date getFirstOfWeek(Date date) {
        DateTime dt = new DateTime(date);
        dt = dt.withDayOfWeek(1);
        return dt.toDate();
    }

    /**
     * 获得当前日期所在周的最后一天(星期天).
     *
     * @return Date
     */
    public static Date getLastOfWeek() {
        return getLastOfWeek(new Date());
    }

    /**
     * 获得日期所在周的最后一天(星期天).
     *
     * @param date 日期
     * @return Date
     */
    public static Date getLastOfWeek(Date date) {
        DateTime dt = new DateTime(date);
        dt = dt.withDayOfWeek(7);
        return dt.toDate();
    }

    /**
     * 是否是今天.
     *
     * @param date 日期
     * @return true, if checks if is today
     */
    public static boolean isToday(Date date) {
        int dateInt = getDateInt(date);
        return DateUtils.isToday(dateInt);
    }

    /**
     * 是否是今天.
     *
     * @param dateInt 日期
     * @return true, if checks if is today
     */
    public static boolean isToday(int dateInt) {
        int today = DateUtils.getCurrentDateInt();
        return today == dateInt;
    }

    /**
     * 日期1的时间是否早于日期2
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return 是返回true;否返回false
     */
    public static boolean isTimeBefore(Date date1, Date date2) {
        DateTime dt1 = new DateTime(date1);
        DateTime dt2 = new DateTime(date2);
        return dt1.getMillisOfDay() < dt2.getMillisOfDay();
    }

    /**
     * 转换为Calendar类型.
     *
     * @param date
     * @return Calendar
     */
    public static Calendar toCalendar(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar;
    }

    /**
     * 设置年份.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setYears(Date date, int amount) {
        return set(date, Calendar.YEAR, amount);
    }

    /**
     * 设置月份.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setMonths(Date date, int amount) {
        return set(date, Calendar.MONTH, amount);
    }

    /**
     * 设置天.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setDays(Date date, int amount) {
        return set(date, Calendar.DAY_OF_MONTH, amount);
    }

    /**
     * 设置小时.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setHours(Date date, int amount) {
        return set(date, Calendar.HOUR_OF_DAY, amount);
    }

    /**
     * 设置分钟.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setMinutes(Date date, int amount) {
        return set(date, Calendar.MINUTE, amount);
    }

    /**
     * 设置秒.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setSeconds(Date date, int amount) {
        return set(date, Calendar.SECOND, amount);
    }

    /**
     * 设置毫秒.
     *
     * @param date   the date
     * @param amount the amount
     * @return the date
     */
    public static Date setMilliseconds(Date date, int amount) {
        return set(date, Calendar.MILLISECOND, amount);
    }

    /**
     * 设置日期属性.
     *
     * @param date          日期对象
     * @param calendarField 字段
     * @param amount        值
     * @return Date
     */
    private static Date set(Date date, int calendarField, int amount) {
        if (date == null)
            throw new IllegalArgumentException("The date must not be null");
        Calendar c = Calendar.getInstance();
        c.setLenient(false);
        c.setTime(date);
        c.set(calendarField, amount);
        return c.getTime();
    }


    /**
     * 获取当年的第一天
     * @return
     *      
     */
    public static Date getCurrYearFirst() {
        Calendar currCal = Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getYearFirst(currentYear);
    }

    /**
     * 获取当年的最后一天
     * @return
     *      
     */
    public static Date getCurrYearLast() {
        Calendar currCal = Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getYearLast(currentYear);
    }

    /**
     * 获取某年第一天日期
     * @param year 年份
     * @return Date
     *      
     */
    public static Date getYearFirst(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        Date currYearFirst = calendar.getTime();
        return currYearFirst;
    }

    /**
     * 获取某年最后一天日期
     * @param year 年份
     * @return Date
     *      
     */
    public static Date getYearLast(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        Date currYearLast = calendar.getTime();

        return currYearLast;
    }


    /**
     * 获取当前日期的前后月份的日期
     * @param nowTime
     * @param month
     * @return
     * @throws ParseException
     */
    public static String getMonthBeforeOrLast(String nowTime, int month)throws ParseException {

        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat(STYLE_DATE_TIME);
        if(StringUtils.isNotBlank(nowTime)){
            date = dateFormat.parse(nowTime);
        }

        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(date);//把当前时间赋给日历
        calendar.add(calendar.MONTH, month); //设置为前2月，可根据需求进行修改
        date = calendar.getTime();//获取2个月前的时间
        return dateFormat.format(date);
    }


    public static String getMonthBeforeOrLastCurrentTime(int month){
        try {
            return getMonthBeforeOrLast(null, month);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}
